import ast

import traceback

from dragon_ai import *

# 自我介绍
prompt_template2 = """  
要让 LLM 系统性构建 “覆盖人类生活方方面面的同音异义字 / 词库”，核心是先建立 **“分层分类框架”**（给 LLM 明确的 “内容边界”），再通过 “指令引导” 让 LLM 按框架填充内容
先拆解 “人类生活” 的核心领域，再逐层细化到具体场景 / 情境，避免 LLM 输出混乱或遗漏。框架需明确 “大类→场景→子情境”，每个层级对应 “同音异义字 / 词的使用场景”示例如下：
一级大类（覆盖生活领域）	二级场景（大类下的具体场景）	三级子情境（场景下的细分场景 / 动作）
1. 日常起居	        1.1 饮食烹饪	            买菜称重、调料添加、厨具使用
                    1.2 居家整理	            衣物收纳、家具摆放、清洁打扫
2. 学习工作	        2.1 知识学习	            数学计算、语文写作、英语阅读
                    2.2 职场办公	            会议记录、文件审批、项目推进
现在有如下一级大类和对应的二级场景示例，请给出尽可能（50个以上）多的这个一级大类下面的二级场景（不能包括已有的）：
要求仅仅回复 “二级场景”和其“例如” 即可，不需要具体描述每个子情境下的具体内容。用***分隔每个子情境。
一级大类：{}
二级大类已有内容（示例）：
{}
回答：
"""

prompt_template3 = """  
要让 LLM 系统性构建 “覆盖人类生活方方面面的同音异义字 / 词库”，核心是先建立 **“分层分类框架”**（给 LLM 明确的 “内容边界”），再通过 “指令引导” 让 LLM 按框架填充内容
先拆解 “人类生活” 的核心领域，再逐层细化到具体场景 / 情境，避免 LLM 输出混乱或遗漏。框架需明确 “大类→场景→子情境”，每个层级对应 “同音异义字 / 词的使用场景”示例如下：
一级大类（覆盖生活领域）	二级场景（大类下的具体场景）	三级子情境（场景下的细分场景 / 动作）
1. 日常起居	        1.1 饮食烹饪	            买菜称重、调料添加、厨具使用
                    1.2 居家整理	            衣物收纳、家具摆放、清洁打扫
2. 学习工作	        2.1 知识学习	            数学计算、语文写作、英语阅读
                    2.2 职场办公	            会议记录、文件审批、项目推进
现在有如下一级大类和其下面的二级大类，以及部分三级子情景的示例，请给出尽可能（100个以上）多的这个2级大类下面的3级场景（不能包括已有的）：
要求仅回答 “三级子情景”即可，不需要具体描述每个子情景下的具体内容。用***分隔每个子情景。
一级大类：{}
二级大类：{}
三级子情景已有内容（示例）：
{}
回答：
"""


prompt_template4 = """  
要让 LLM 系统性构建 “覆盖人类生活方方面面的同音异义字 / 词库”，核心是先建立 **“分层分类框架”**（给 LLM 明确的 “内容边界”），再通过 “指令引导” 让 LLM 按框架填充内容
先拆解 “人类生活” 的核心领域，再逐层细化到具体场景 / 情境，避免 LLM 输出混乱或遗漏。框架需明确 “大类→场景→子情境”，每个层级对应 “同音异义字 / 词的使用场景”示例如下：
一级大类（覆盖生活领域）	二级场景（大类下的具体场景）	三级子情境（场景下的细分场景 / 动作）
1. 日常起居	        1.1 饮食烹饪	            买菜称重、调料添加、厨具使用
                    1.2 居家整理	            衣物收纳、家具摆放、清洁打扫
2. 学习工作	        2.1 知识学习	            数学计算、语文写作、英语阅读
                    2.2 职场办公	            会议记录、文件审批、项目推进
现在有如下一级大类和其下面的二级大类和其下面的三级子情景，请给出1个在该子场景下面的可能出现的同音异义词的使用句子。
回答句式：用json的格式回答，要求有如下key: 句子， 同音词， 易混的同音词。
要求给出的同音异义词要尽可能精巧，这个词另一个同音的常用词汇，在没有上下文的时候是区分不出来两个词的，而有了上下文就可以明确知道用A词而不是相同发音的B词了。
示例1：
同音异议句如下：
句子：原子弹是用铀做的还是用钚做的？
同音词：原子弹、铀、钚
易混的同音词：园子蛋、油、布


提问：
一级大类：{}
二级大类：{}
三级子情景：{}
回答：
"""

prompt_template5 = """  
任务改写：专有名词识别任务指令
请基于给定的 “一级大类→二级大类→三级子情景” 分层分类框架，完成以下专有名词识别任务：
识别目标：定位该三级子情景下实际使用中会出现的领域专有名词；
核心要求：构造 1 个包含该专有名词的场景化句子，同时为该专有名词匹配 1 组 “易混同音词”；
输出格式：以 JSON 格式返回，包含 3 个固定 key：
"句子"：含场景专有名词的通顺语句；
"专有名词"：该场景下的领域特定词汇；
"混淆词"：与专有名词发音相同、无上下文易混淆的常用词。 注意！！！！！！：***转悠名词和混淆词一定不能是一个词，而且要求发音尽可能相同***
示例1：
提问
（一级大类 - 医疗健康类；二级大类 - 就医问诊；三级子情景 - 处方开具）
json
{{
  "句子": "医生为高血压患者开具了降压的处方药，需凭处方单在药房领取。",
  "专有名词": "处方药",
  "混淆词": "处房药"
}}
示例2：
提问：
(一级大类：工业制造类二级大类：金属加工 三级子情景：钢材热处理)
回答：
json
{{
  "句子": "对低碳钢进行淬火处理时，需严格控制加热温度和冷却速度，以提升钢材硬度。",
 "专有名词": "淬火",
  "混淆词": "淬活"
}}
一级大类：{}
二级大类：{}
三级子情景：{}
回答：
"""

prompt_template6 = """
任务：专业名词收集任务指令
请基于给定的 “一级大类→二级大类→三级子情景” 分层分类框架，完成以下专业名词收集任务：
识别目标：定位该三级子情景下实际使用中会出现的领域专业名词（需符合场景属性，具备较强的领域专业性和场景适配性）；
核心要求：列出该场景下10个专业名词，需尽可能体现领域深度，避免过于基础或通用的词汇；
输出格式：包含10个该场景下专业名词的数组，名词需准确规范。，，注意：只需要输出数组，只输出数组，只输出数组。

示例（基于框架：一级大类 - 建筑工程类；二级大类 - 结构加固；三级子情景 - 既有建筑改造）
["锚固剂", "植筋", "碳纤维布加固", "粘钢加固", "裂缝注浆", "托换技术", "截面加大法", "体外预应力加固", "喷射混凝土", "锚栓"]
提问：
一级大类：{}
二级大类：{}
三级子情景：{}
回答：
"""

# 获得每个场景的关键词
prompt_template7 = """
# 任务：高难度领域专业名词收集
请严格基于用户给定的“三级子情景”（需完全贴合场景属性，不脱离场景范畴），收集该场景下实际使用中**极易发生语音识别错误**且**专业性极强、认知门槛高**的领域专有名词。

## 核心要求
1. 名词属性：必须是该“三级子情景”下的领域专属词汇，具备强场景适配性，严禁出现基础通用词（如“医生”“工具”等）或跨场景通用词；
2. 难度标准：优先选择行业内小众、非从业者难认知、发音易与日常词混淆（如“钚”易混“布”）的词汇，且单个名词长度限定为2-4字；
3. 数量要求：固定输出10个专业名词，每个名词需准确规范，无错别字或歧义。

## 输出格式
仅输出包含10个专业名词的数组，不附加任何其他文字或说明。

## 示例1
场景：建筑改造
["锚固剂", "植筋", "锚栓", "碳纤维布", "界面剂", "抱箍", "植筋胶", "托梁", "化学锚栓", "灌浆料"]
## 示例2
场景：古生物化石修复
["髁突片", "喙状突", "齿列槽", "基质胶", "围岩楔", "髓腔针", "裂隙剂", "铸型模", "骨化层", "嵌合钉"]
## 示例3
场景：核反应堆退役处理
["衰变桶", "去污剂", "屏蔽铅", "活化件", "熔渣罐", "过滤芯", "剂量仪", "废燃料", "石墨块", "冷却剂"]

## 提问
一级大类：{}
二级大类：{}
三级子情景：{}
"""

prompt_template8 = """
任务：指定场景下专业词处理（句子构造 + 混淆词匹配 + 思考过程生成）
请基于给定的三级情景（场景的具体细分情景），围绕指定领域名词（数量不定），完成 “句子构造、同音混淆词匹配、第一人称思考过程生成” 三项核心任务，最终以 JSON 格式输出完整结果。
核心要求
1. 构造场景化句子
需紧密贴合 “三级子情景” 的实际场景属性（如 “户外徒步” 关联行走辅助、“原子弹材料讨论” 关联核材料）；
必须包含指定专有名词，语句通顺、符合该场景下的真实使用逻辑（避免脱离场景的通用句子）。
2. 匹配同音混淆词
为每个专有名词匹配 1 组 “同音混淆词”：发音与专有名词完全相同（无上下文时易混淆）、为日常常用词（与专有名词的领域属性有明显区分，如 “铀” 对应日常词 “油”）；
若专有名词为多个（用 “、” 分隔），混淆词需数量对应、一一匹配。
3. 生成第一人称思考过程
以 “我” 为视角，分三步展开：
① 先通过 “易听清的词” 推测用户可能在做的事（如 “听到‘原子弹’‘做的’，猜用户在聊原子弹的构成材料”）；
② 指出 “听不清的词” 及其发音（拼音，无需声调）；
③ 结合三级子情景和专业方向，对比混淆词与专有名词的合理性，最终确定专有名词（如 “‘油’是日常燃料，和原子能无关，‘铀’才是核材料”）；
语言简洁自然，避免冗余，聚焦 “语音理解→发音提取→逻辑判断” 的流程。
4. 补充场景分类
根据 “三级子情景” 和 “专有名词”，反向补充 “一级大类”（场景顶层分类，如 “日常基础沟通类”“原子能相关类”）和 “二级场景”（场景中层分类，需加括号补充具体描述，如 “娱乐休闲场景（如观看演出、参与游戏）”）。
输出格式
需以 JSON 格式返回，包含 5 个固定 key，不可缺失或修改 key 名：
"专有名词"：指定的领域专业词汇（可单个或多个，多个用 “、” 分隔）；
"混淆词"：与专有名词发音相同的日常易混词（数量对应，多个用 “、” 分隔）；
"混淆词拼音"：同音混淆词的拼音（无需声调，多个用 “、” 分隔，与混淆词一一对应）；
"造句"：含专有名词、符合三级子情景的通顺语句；
"思考"：第一人称视角的思考过程（按 “推测用户行为→提取模糊发音→逻辑判断专有名词” 展开）。

注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。
注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。
注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。
注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。
注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。
注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。
注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。
注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。
注意：：专业词和混淆词一定不能是一个词，而且要求发音尽可能相同。

示例1：
场景：户外徒步   
名词：登山杖
名词拼音：dengshanzhang
json
{{
  "专有名词": "登山杖",
  "混淆词": "登山丈",
  "混淆词拼音": "dengshanzhang"
  "造句": "这段徒步路线的碎石坡很滑，用登山杖支撑着走能稳不少，还能减轻膝盖压力。"
  "思考":  "我能比较确定“徒步”“坡滑”“支撑”“膝盖” 等听得清楚的词，感觉是在说户外活动时用什么东西辅助走路。有个词听不太清，发音是 dengshanzhang。结合前面说的场景，应该是种能帮着在山上走路的工具，“杖” 是棍状的能支撑，“丈” 是长度单位不对，所以应该是 “登山杖”。"
}}
示例2：
场景：原子能聊天
名词：铀、钚
名词拼音：you、bu
json
{{
  "专有名词": "铀、钚",
  "混淆词": "油、布",
  "混淆词拼音": "you、bu",
  "造句": "原子弹是用铀做的还是用钚做的？"
  "思考": "我能清楚听到 “原子弹”“做的” 这些词，猜用户大概在聊和原子弹相关的构成材料。里面有两个词容易有同音字，听不太准，发音分别是 you 和 bu。结合 “原子能” 这个场景，得是能用于原子弹的物质，“油” 是日常燃料、“布” 是纺织材料，都和原子能无关；而 “铀”“钚” 是原子能领域里常见的核材料，刚好对应发音 you、bu，所以确定是这两个专有名词。"
}}
示例3：
场景：空调系统节能改造
名词：风阀、冷源
名词拼音：fengfa、lengyuan
{{                                                                                                                                                                          
"专有名词": "风阀、冷源",                                                                                                                                                  
"混淆词": "风发、冷原",                                                                                                                                                    
"混淆词拼音": "fengfa、lengyuan",                                                                                                                                          
"造句": "空调系统节能改造时需优先检查风阀启闭是否灵活，同时优化冷源分配策略以降低能耗。",                                                                                  
"思考": "我能清楚听到 '空调' '节能改造' '能耗' 等词，猜用户大概在聊建筑节能相关的设备调整。里面有两个词容易有同音字，听不太准，发音分别是 fengfa 和 lengyuan。结合 '空调 系统' 这个场景，'风阀' 是控制气流的阀门部件，'冷源' 是制冷系统的能量来源，而 '风发' 是描述发型的普通词汇，'冷原' 指寒冷地域，明显与建筑节能改造无关，所以确定是这两个专业术语。"                                                                                                                                                                      
}} 
提问：
三级子情景：{}
名词：{}
名词拼音：{}

回答：
"""

prompt_template9 = """
任务：指定场景下专业词处理（句子构造 + 混淆词匹配 + 思考过程生成）
请基于给定的情景（场景的具体细分情景），围绕指定领域名词（数量不定），完成 “句子构造、第一人称思考过程生成” 2项核心任务，最终以 JSON 格式输出完整结果。
核心要求
1. 构造场景化句子
需紧密贴合 “情景” 的实际场景属性（如 “户外徒步” 关联行走辅助、“原子弹材料讨论” 关联核材料）；
必须包含指定专有名词，语句通顺、符合该场景下的真实使用逻辑（避免脱离场景的通用句子）。
2. 生成第一人称思考过程
以 “我” 为视角，分三步展开：
① 先通过 “易听清的词” 推测用户可能在做的事（如 “听到‘原子弹’‘做的’，猜用户在聊原子弹的构成材料”）；
② 指出 “听不清的词” 及其发音（拼音，无需声调）；
③ 结合三级子情景和专业方向,指出专有名词的合理性，最终确定专有名词（如 “‘油’是日常燃料，和原子能无关，‘铀’才是核材料”）；
语言简洁自然，避免冗余，聚焦 “语音理解→发音提取→逻辑判断” 的流程。

输出格式
需以 JSON 格式返回，包含 4 个固定 key，不可缺失或修改 key 名：
"专有名词"：指定的领域专业词汇（可单个或多个，多个用 “、” 分隔）；
"专有词拼音"：拼音（无需声调，多个用 “、” 分隔，与专有名词一一对应）；
"造句"：含专有名词、符合三级子情景的通顺语句；
"思考"：第一人称视角的思考过程（按 “推测用户行为→提取模糊发音→逻辑判断专有名词” 展开）。

注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。
注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。
注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。
注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。
注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。

示例1：
场景：户外徒步   
名词：登山杖
名词拼音：dengshanzhang
json
{{
  "专有名词": "登山杖",
  "专有词": "dengshanzhang"
  "造句": "这段徒步路线的碎石坡很滑，用登山杖支撑着走能稳不少，还能减轻膝盖压力。"
  "思考":  "我能比较确定“徒步”“坡滑”“支撑”“膝盖” 等听得清楚的词，感觉是在说户外活动时用什么东西辅助走路。有个词听不太清，发音是 dengshanzhang。结合前面说的场景，应该是种能帮着在山上走路的工具，“杖” 是棍状的能支撑，“丈” 是长度单位不对，所以应该是 “登山杖”。"
}}
示例2：
场景：原子能相关聊天
名词：铀、钚
名词拼音：you、bu
json
{{
  "专有名词": "铀、钚",
  "专有词拼音": "you、bu",
  "造句": "原子弹是用铀做的还是用钚做的？"
  "思考": "我能清楚听到 “原子弹”“做的” 这些词，猜用户大概在聊和原子弹相关的构成材料。里面有两个词容易有同音字，听不太准，发音分别是 you 和 bu。结合 “原子能” 这个场景，得是能用于原子弹的物质。“铀”“钚” 是原子能领域里常见的核材料，刚好对应发音 you、bu，所以确定是这两个专有名词。"
}}
示例3：
场景：空调系统节能改造
名词：风阀、冷源
名词拼音：fengfa、lengyuan
{{                                                                                                                                                                          
"专有名词": "风阀、冷源",                                                                                                                                                                                                                                                                                                 
"专有词拼音": "fengfa、lengyuan",                                                                                                                                          
"造句": "空调系统节能改造时需优先检查风阀启闭是否灵活，同时优化冷源分配策略以降低能耗。",                                                                                  
"思考": "我能清楚听到 '空调' '节能改造' '能耗' 等词，猜用户大概在聊建筑节能相关的设备调整。里面有两个词容易有同音字，听不太准，发音分别是 fengfa 和 lengyuan。结合 '空调 系统' 这个场景，'风阀' 是控制气流的阀门部件，'冷源' 是制冷系统的能量来源，可以确定是这两个词很合适。"                                                                                                                                                                      
}} 
提问：
场景：{}
名词：{}
名词拼音：{}

回答：
"""

prompt_template10 = """
任务：指定场景下专业词处理（句子构造 + 混淆词匹配 + 思考过程生成）
请基于给定的情景（场景的具体细分情景），围绕指定领域名词（数量不定），完成 “句子构造、第一人称思考过程生成” 2项核心任务，最终以 JSON 格式输出完整结果。
核心要求
1. 构造场景化句子
需紧密贴合 “情景” 的实际场景属性（如 “户外徒步” 关联行走辅助、“原子弹材料讨论” 关联核材料）；
必须包含指定专有名词，语句通顺、符合该场景下的真实使用逻辑（避免脱离场景的通用句子）。
2. 生成第一人称思考过程
以 “我” 为视角，分三步展开：
① 先通过 “易听清的词” 推测用户可能在做的事和可能都方向领域（如 “听到‘原子弹’‘做的’，猜用户在聊原子弹的构成材料”）；
② 再分析出“听不清的词”
③ 结合情景和专业方向,指出“听不清词”的合理性，最终确定专有名词（如 “‘油’是日常燃料，和原子能无关，‘铀’才是核材料”）；
语言简洁自然，避免冗余，聚焦 “语音理解→发音提取→逻辑判断” 的流程。

输出格式
需以 JSON 格式返回，包含 4 个固定 key，不可缺失或修改 key 名：
"专有名词"：指定的领域专业词汇（可单个或多个，多个用 “、” 分隔）；
"造句"：含专有名词、符合三级子情景的通顺语句；
"思考"：第一人称视角的思考过程（按 “推测用户行为→提取模糊发音→逻辑判断专有名词” 展开）。

注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。
注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。
注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。
注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。
注意：输入的场景信息只是用来造句，think内容中不能透漏场景信息，而是只能根据文本进行推理。

示例1：
场景：户外徒步   
名词：登山杖
json
{{
  "专有名词": "登山杖",
  "造句": "这段徒步路线的碎石坡很滑，用登山杖支撑着走能稳不少，还能减轻膝盖压力。"
  "思考":  "我能比较确定“徒步”“坡滑”“支撑”“膝盖” 等听得清楚的词，感觉是在说户外活动时用什么东西辅助走路。也有一些不是很确定的地方，结合前面说的场景，说的应该是种能帮着在山上走路的工具，因此很可能是“登山杖”。"
}}
示例2：
场景：原子能相关聊天
名词：铀、钚
json
{{
  "专有名词": "铀、钚",
  "造句": "原子弹是用铀做的还是用钚做的？"
  "思考": "我能清楚听到 “原子弹”“做的” 这些词，猜用户大概在聊和原子弹相关的构成材料。里面有两个词容易有同音字，听不太准。而“铀”“钚” 是原子能领域里常见的核材料，很可能是这两个专有名词。"
}}
示例3：
场景：空调系统节能改造
名词：风阀、冷源
{{                                                                                                                                                                          
"专有名词": "风阀、冷源",                                                                                                                                                                                                                                                                                                                                                                                                                               
"造句": "空调系统节能改造时需优先检查风阀启闭是否灵活，同时优化冷源分配策略以降低能耗。",                                                                                  
"思考": "我能清楚听到 '空调' '节能改造' '能耗' 等词，猜用户大概在聊建筑节能相关的设备调整。里面有两个词容易有同音字，听不太准。结合 '空调系统' 这个场景，'风阀' 是控制气流的阀门部件，'冷源' 是制冷系统的能量来源，可以确定是这两个词很合适。"                                                                                                                                                                      
}} 
提问：
场景：{}
名词：{}
回答：
"""



def has_no_chinese(s):
    """
    判断字符串是否完全不含有中文

    参数:
        s: 待检查的字符串

    返回:
        True: 完全不含中文
        False: 含有中文
    """
    # 匹配中文的正则表达式（包括基本汉字和常见中文符号）
    chinese_pattern = re.compile(
        r'[\u4e00-\u9fa5\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b]')
    # 检查是否有匹配的中文
    return not bool(chinese_pattern.search(s))



def do_test_for_little():
    """"""
    info_dict = load_dict_from_json('./info4contextASR_2.json')
    output_path = './info4contextASR_2_full.json'
    for key, info_list in info_dict.items():
        demo_str = ""
        for info in info_list:
            infor_str = f"***{info}***\n"
            demo_str += infor_str
        template = prompt_template2.format(key, demo_str)
        print_info(template)
        res = qwen3_vllm_chat(template)
        print_info(res)
        result = re.findall(r'\*\*\*(.*?)\*\*\*', res)
        print_list(result)
        if len(result) > 0:
            info_dict[key].extend(result)
    write_dict_to_json(info_dict, output_path)


def extract_scene_and_list(input_str):
    # 1. 提取主场景：分割“（如”，取左侧内容并去除前后空格
    main_scene = input_str.split("（如")[0].strip()

    # 2. 提取括号内子项：匹配“（如XXX）”中的XXX，按“、”分割为列表
    # 正则匹配“（如”和“）”之间的所有内容，非贪婪模式避免多括号干扰
    sub_items_match = re.search(r'（如(.*?)）', input_str)
    # 若匹配到结果则按“、”分割，否则返回空列表
    sub_items_list = sub_items_match.group(1).split("、") if sub_items_match else []

    # 3. 清理子项列表中的空格（可选，根据实际格式调整）
    sub_items_list = [item.strip() for item in sub_items_list]

    return main_scene, sub_items_list

def little_func(key, info_list, output_dir):
    new_info_dict= {key: {}}
    for class_2 in info_list:
        """"""
        scene, demo_list = extract_scene_and_list(class_2)
        print_info(f"一级大类：{key}  二级场景：{scene}")
        print_list(demo_list)
        demo_str = ""
        for demo in demo_list:
            infor_str = f"***{demo}***\n"
            demo_str += infor_str
        template = prompt_template3.format(key, scene, demo_str)
        print_info(template)
        res = qwen3_vllm_chat(template)
        print_info(res)
        result = re.findall(r'\*\*\*(.*?)\*\*\*', res)
        print_list(result)
        result.extend(demo_list)
        print_list(result)
        new_info_dict[key][class_2] = result
    output_path = os.path.join(output_dir, f"{key}.json")
    write_dict_to_json(new_info_dict, output_path)


def get_json_files_with_os(directory):
    """使用os模块获取目录下所有.json文件的绝对路径"""
    # 确保目录存在
    if not os.path.isdir(directory):
        raise ValueError(f"目录不存在: {directory}")

    json_files = []
    # 遍历目录
    for filename in os.listdir(directory):
        # 检查文件是否以.json结尾
        if filename.endswith('.json'):
            # 获取绝对路径并添加到列表
            json_files.append(os.path.abspath(os.path.join(directory, filename)))

    return json_files
def do_test_for_little2():
    """"""
    info_dict = load_dict_from_json('./info4contextASR_2_full.json')
    output_path = './info4contextASR_2_full_2.json'
    output_dir = './info4contextASR_2_full_2'
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    new_info_dict = {}
    runner = DragonDynamicProcessPool()
    for key, info_list in info_dict.items():
        runner.add_thread(little_func, [key, info_list, output_dir])
    runner.start()
    print_info("等待所有线程完成...")
    res_jsonfiles = get_json_files_with_os(output_dir)
    for jsonfile in res_jsonfiles:
        new_info_dict.update(load_dict_from_json(jsonfile))
    write_dict_to_json(new_info_dict, output_path)
    print_info("全部完成！")


def little_func2(key, info_list, output_dir):
    new_info_dict= {key: {}}
    for class_2 in info_list:
        """"""
        scene, demo_list = extract_scene_and_list(class_2)
        print_info(f"一级大类：{key}  二级场景：{scene}")
        print_list(demo_list)
        demo_str = ""
        for demo in demo_list:
            infor_str = f"***{demo}***\n"
            demo_str += infor_str
        template = prompt_template3.format(key, scene, demo_str)
        print_info(template)
        res = qwen3_vllm_chat(template)
        print_info(res)
        result = re.findall(r'\*\*\*(.*?)\*\*\*', res)
        print_list(result)
        result.extend(demo_list)
        print_list(result)
        new_info_dict[key][class_2] = result
    output_path = os.path.join(output_dir, f"{key}.json")
    write_dict_to_json(new_info_dict, output_path)

def little_func3(key,scene2,scene3,new_info_dict, if_think):
    try:
        template = prompt_template7.format(key, scene2, scene3)
        res = qwen3_vllm_chat(template, think=if_think)
        # result = re.findall(r'\*\*\*(.*?)\*\*\*', res)
        print_info(f"一级大类：{key}  二级场景：{scene2}  三级子情景：{scene3}")
        if if_think:
            res = res.split("</think>")[1]
        item_list = ast.literal_eval(res)
        print_list(item_list)
        new_info_dict[key][scene2][scene3] = item_list
    except Exception as e:
        print_info(f"出错了：{e}")
        traceback.print_exc()

def do_test_for_little3():
    """"""
    new_info_dict = {}
    big_info_dict = load_dict_from_json('./info4contextASR_2_full_2.json')
    output_path = './context_asr_word_short_full.json'
    runner = DragonFixedThreadPool(50)
    if_think = False
    for key, info_dict in big_info_dict.items():
        new_info_dict[key] = {}
        for scene2, scene3_list in info_dict.items():
            new_info_dict[key][scene2] = {}
            time_now = time.time()
            for scene3 in scene3_list:
                new_info_dict[key][scene2][scene3] = []
                runner.add_thread(little_func3, [key, scene2, scene3, new_info_dict, if_think])
    print_info("等待所有线程完成...")
    runner.start()
    print_info("全部完成！")
    write_dict_to_json(new_info_dict, output_path)


def do_get_sentence_from_word_and_scene(scene1, scene2,scene3, word_str, word_pinyin_str, if_think=False):
    template = prompt_template9.format(scene3, word_str, word_pinyin_str)
    # print_info(template)
    time_now = time.time()
    res = qwen3_vllm_chat(template, think=if_think)
    print_info(f"耗时：{time.time() - time_now}秒")
    if if_think:
        res = res.split("</think>")[1]
    res_dict = ast.literal_eval(res)
    random_str = ''.join(random.sample(string.ascii_letters + string.digits, 16))
    new_dict = {
        'key': random_str,
        'txt': res_dict['造句'],
        'extra': {
            'words': res_dict['专有名词'].split("、"),
            'pinyin': res_dict['专有词拼音'].split("、"),
            'think_str': res_dict['思考'],
            "scene1": scene1,
            "scene2": scene2,
            "scene3": scene3
        }
    }
    return new_dict

def little_func4(scene1,scene2,scene3,big_info_dict ,big_dict_list, if_think):
    try:
        words_list = big_info_dict[scene1][scene2][scene3]
        words_pinyin_list = [do_get_pinyin(word, False) for word in words_list]
        print_info(f"一级大类：{scene1}  二级场景：{scene2}  三级子情景：{scene3}")
        scene2_new = scene2.split("（")[0]
        # 首先是遍历得到单个词的情况
        for index in range(len(words_list)):
            word = words_list[index]
            word_pinyin = words_pinyin_list[index]
            new_dict = do_get_sentence_from_word_and_scene(scene1, scene2_new,scene3, word, word_pinyin, if_think)
            print_info(new_dict)
            big_dict_list.append(new_dict)
        # 然后说多个词的情况
        # 2个词的情况， 有5个，每次随机取2个
        for i in range(5):
            word_list_tmp = random.sample(words_list, 2)
            word_pinyin_list_tmp = [do_get_pinyin(word, False) for word in word_list_tmp]
            word_str = "、".join(word_list_tmp)
            word_pinyin_str = "、".join(word_pinyin_list_tmp)
            new_dict = do_get_sentence_from_word_and_scene(scene1, scene2_new,scene3, word_str, word_pinyin_str, if_think)
            print_info(new_dict)
            big_dict_list.append(new_dict)
        # 3个词的情况， 有2个，每次随机取3个
        for i in range(2):
            word_list_tmp = random.sample(words_list, 3)
            word_pinyin_list_tmp = [do_get_pinyin(word, False) for word in word_list_tmp]
            word_str = "、".join(word_list_tmp)
            word_pinyin_str = "、".join(word_pinyin_list_tmp)
            new_dict = do_get_sentence_from_word_and_scene(scene1, scene2_new,scene3, word_str, word_pinyin_str, if_think)
            print_info(new_dict)
            big_dict_list.append(new_dict)
        # 4个词的情况， 有5个，每次随机取1个
        for i in range(1):
            word_list_tmp = random.sample(words_list, 4)
            word_pinyin_list_tmp = [do_get_pinyin(word, False) for word in word_list_tmp]
            word_str = "、".join(word_list_tmp)
            word_pinyin_str = "、".join(word_pinyin_list_tmp)
            new_dict = do_get_sentence_from_word_and_scene(scene1, scene2_new,scene3, word_str, word_pinyin_str, if_think)
            print_info(new_dict)
            big_dict_list.append(new_dict)

    except Exception as e:
        print_info(f"出错了：{e}")
        traceback.print_exc()

def do_test_for_little4():
    """"""
    big_info_dict = load_dict_from_json('./context_asr_word_short_full.json')
    output_txt_jsonl_path = './context_asr_sentence_full.jsonl'
    runner = DragonFixedThreadPool(50)
    if_think = False
    big_dict_list = []
    for scene1, info_dict in big_info_dict.items():
        for scene2, scene3_list in info_dict.items():
            for scene3 in scene3_list:
                """"""
                runner.add_thread(little_func4, [scene1,scene2,scene3, big_info_dict, big_dict_list, if_think])
    runner.start()
    print_info("全部完成！")
    write_dict_list_to_jsonl(big_dict_list, output_txt_jsonl_path)

from pypinyin import pinyin, Style
def do_get_pinyin(word, yindiao=False):
    """
    获取汉字的拼音
    :param word: 待转换的汉字字符串
    :param yindiao: 是否包含声调，True包含，False不包含
    :return: 拼接后的拼音字符串（多音字取第一个读音）
    """
    if not word:
        return ""

    # 根据是否需要声调选择拼音风格
    style = Style.TONE if yindiao else Style.NORMAL
    # 转换为拼音列表（每个汉字对应一个列表项）
    pinyin_list = pinyin(word, style=style, errors='ignore')
    # 拼接拼音（多音字取第一个读音）
    result = ''.join([item[0] for item in pinyin_list])

    return result





# 将提前批量的单音色数据整理好成shard格式，以供训练使用
def do_prepare_for_contextASR_shard():
    """"""
    input_txt_jsonl_path = '/home/A02_tmpdata3/code/dragon_ai/context_asr_sentence_few.jsonl'
    wav_row_dir = "/home/A02_tmpdata2/data/context_asr_sentence_few/wav"
    output_dir = "/home/A02_tmpdata2/data/context_asr_sentence_few/wav_shards"
    makedirs(output_dir)
    task_name = "<TRANSCRIBE> <THINK>"
    new_dict_list = []
    data_list_path_output = os.path.join(output_dir, "data.list")
    wav_scp_path_output = os.path.join(output_dir, "wav.scp")
    wav_dict = do_find_files_from_dir(wav_row_dir, 'wav', )
    write_dict_to_scp(wav_dict, wav_scp_path_output)
    dict_list = load_dict_list_from_jsonl(input_txt_jsonl_path)
    for dict_item in dict_list:
        key = dict_item['key']
        if key not in wav_dict:
            print_error(f"找不到对应的音频文件：{key}")
            continue
        wav_path = wav_dict[key]
        dict_item['wav'] = wav_path
        dict_item['task'] = task_name
        new_dict_list.append(dict_item)
    random.shuffle(new_dict_list)
    write_dict_list_to_jsonl(new_dict_list, data_list_path_output)
    print_info(f"raw数据集已准备完成，输出目录：{output_dir}")
    print_list(new_dict_list[:10])
    print_info(f"数据集数量：{len(new_dict_list)}")
    print_info("开始打shard包")
    do_make_shards_common(data_list_path_output, os.path.join(output_dir, "shards"),do_recover=False)

def do_get_new_data_list():
    """"""
    shards_info_path = "/home/A02_tmpdata1/data/context_asr_sentence_full/shards/data.list"
    dict_list = load_dict_list_from_jsonl(shards_info_path)
    shard_info_dict = {}
    for dict_item in dict_list:
        key = dict_item['key']
        tar_key_path = dict_item['tar_path_key']
        shard_info_dict[key] = tar_key_path

    long_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file.jsonl"
    long_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_no_punctuation.jsonl"
    medium_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_medium_think.jsonl"
    medium_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_medium_no_punctuation.jsonl"
    short_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_think.jsonl"
    short_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_no_punctuation.jsonl"
    # 为每一个文件加入tar_key_path
    for path in [medium_path, medium_no_punction, short_path, short_no_punction]:
        new_dict_list = []
        dict_list = load_dict_list_from_jsonl(path)
        for dict_item in dict_list:
            key = dict_item['key']
            if key not in shard_info_dict:
                print_error(f"找不到对应的shard文件：{key}")
                continue
            tar_key_path = shard_info_dict[key]
            dict_item['tar_path_key'] = tar_key_path
            new_dict_list.append(dict_item)
        write_dict_list_to_jsonl(new_dict_list, path)
        print_info(f"已为{path}文件添加tar_key_path")
    print_info("全部完成！")


def do_convert_datalist2combines():
    """"""
    long_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file.jsonl"
    long_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_no_punctuation.jsonl"
    medium_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_medium_think.jsonl"
    medium_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_medium_no_punctuation.jsonl"
    short_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_think.jsonl"
    short_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_no_punctuation.jsonl"
    # 为每一个文件加入tar_key_path
    task_name_list = ["<TRANSCRIBE> <THINK> <LONG> <PUNCTUATION>","<TRANSCRIBE> <THINK> <LONG>","<TRANSCRIBE> <THINK> <MEDIUM> <PUNCTUATION>", "<TRANSCRIBE> <THINK> <MEDIUM>", "<TRANSCRIBE> <THINK> <SHORT> <PUNCTUATION>", "<TRANSCRIBE> <THINK> <SHORT>"]
    index = 0
    for path in [long_path, long_no_punction, medium_path, medium_no_punction, short_path, short_no_punction]:
        """"""
        print_info(f"开始处理{path}数据集")
        task_name = task_name_list[index]
        print_info(f"当前任务：{task_name}")
        dataname = os.path.basename(path).split(".")[0]
        print_info(f"开始处理{dataname}数据集")
        output_dir_i = f'/home/A02_tmpdata2/data/context_asr_sentence_full/combine_data/{dataname}'
        do_distribute_datalist_for_conbine_type(
            path,
            output_dir_i,
            task_name,
            tar_dir="/home/A02_tmpdata1/data/context_asr_sentence_full/shards"
        )
        index += 1

def remove_punctuation(input_str):
    """
    高效去除输入字符串中的所有中英文标点符号

    参数:
        input_str (str): 包含标点符号的输入字符串

    返回:
        str: 去除所有标点符号后的字符串
    """
    # 定义中英文标点集合
    punctuation = string.punctuation + "！？｡。，、；：“”‘’《》〈〉【】『』「」﹋～﹑﹐﹔﹕！？｡。，、；：“”‘’《》〈〉【】『』「」﹋～﹑﹐﹔﹕"

    # 创建标点符号到空字符的映射表
    translator = str.maketrans('', '', punctuation)
    # 使用映射表转换字符串，去除所有标点
    return input_str.translate(translator)

def fix_short():
    input_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_think.jsonl"
    output_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_no_punctuation.jsonl"
    short_dict_list = load_dict_list_from_jsonl(input_path)
    # output_short_file = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_no_punctuation.jsonl"
    new_short_dict_list = []
    for dict_i in tqdm(short_dict_list):
        new_txt = remove_punctuation(dict_i['txt'])
        dict_i['txt'] = new_txt
        new_short_dict_list.append(dict_i)
    write_dict_list_to_jsonl(new_short_dict_list, output_path)


def do_fix_all():
    """"""
    task_name_list = ["<TRANSCRIBE> <THINK> <LONG>", "<TRANSCRIBE> <THINK> <LONG> <PUNCTUATION>",
                      "<TRANSCRIBE> <THINK> <MEDIUM>", "<TRANSCRIBE> <THINK> <MEDIUM> <PUNCTUATION>",
                      "<TRANSCRIBE> <THINK> <SHORT>", "<TRANSCRIBE> <THINK> <SHORT> <PUNCTUATION>"]
    long_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file.jsonl"
    long_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_no_punctuation.jsonl"
    medium_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_medium_think.jsonl"
    medium_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_medium_no_punctuation.jsonl"
    short_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_think.jsonl"
    short_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_no_punctuation.jsonl"
    pass

def do_fix_medium():
    short_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_think.jsonl"
    short_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_short_no_punctuation.jsonl"

    medium_path = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_medium_think.jsonl"
    medium_no_punction = "/home/A02_tmpdata2/data/context_asr_sentence_full/valid_file_medium_no_punctuation.jsonl"

    short_dict_list = load_dict_list_from_jsonl(short_path)
    for dict_i in tqdm(short_dict_list):
        think_str = dict_i['extra']['think_str']
        words_list = dict_i['extra']['words']
        new_think_str = f'{think_str}句子中含有的一些易错词，经过语音场景分析，应当采用如下词汇：{"、".join(words_list)}。'
        dict_i['extra']['think_str'] = new_think_str
    write_dict_list_to_jsonl(short_dict_list, medium_path)

    short_no_punction_dict_list = load_dict_list_from_jsonl(short_no_punction)
    for dict_i in tqdm(short_no_punction_dict_list):
        think_str = dict_i['extra']['think_str']
        words_list = dict_i['extra']['words']
        new_think_str = f'{think_str}句子中含有的一些易错词，经过语音场景分析，应当采用如下词汇：{"、".join(words_list)}。'
        dict_i['extra']['think_str'] = new_think_str
    write_dict_list_to_jsonl(short_no_punction_dict_list, medium_no_punction)






if __name__ == '__main__':
    """"""
    # do_test_for_little3()
    # do_test_for_little4()
    # do_get_new_data_list()
    # fix_short()
    do_fix_medium()
    do_convert_datalist2combines()

